package _11_整理题目._0_工具集;

import org.junit.Test;

import java.util.*;

/**
 * Arrays
 *      不返回新数组     void    System.arraycopy(src, srcPos, dest, destPos, length)
 *      返回新数组       []      Arrays.copyOfRange(src, from, to)    [)
 *      返回新数组       []      Arrays.copyOf(src, length)           0)
 *
 *      复制数组：int[] dp = Arrays.copyOf(nums, n);
 *      填充数组：Arrays.fill(arr, 1)
 *      打印数组：System.out.println(Arrays.toString(nums));
 *      数组求和：int total = Arrays.stream(nums).sum();
 *
 *
 * HashSet
 *      .add(ele)       如果重复，返回 false，无异常，不添加，天然去重
 *      .contains()
 *      .iterator()
 *          .hasNext()
 *          .next
 *
 * List
 *      .add(ele)       可以添加重复值
 *
 * HashMap
 *      .put(k, v)      如果重复 k，直接覆盖 v
 *      .get(k)
 *      .containsKey()
 *      .keySet()
 *      map.getOrDefault(k, 0);
 *
 * Queue Deque PriorityQueue
 *      .contains()
 *      .offer()        如果队列满了，返回false，无异常，不添加
 *      .peek()
 *      .poll()
 *
 *      .add()          如果队列满了，抛出异常，不添加
 *      .element()
 *      .remove()
 *
 * Stack
 *      .pop()
 *      .push()
 *      .peek()
 */
public class _03_常用数据结构初始化 {
    
    @Test
    public void main() {
    
        /**
         * 初始化 一维数组 和 二维数组
         */
        int[]   array1 = {2, 5};
        int[][] array2 = {{1, 3}, {6, 9}};

        /**
         * 小根堆：每次 poll 的都是最小的
         * PriorityQueue 默认是小根堆
         * 
         * PriorityQueue  优先队列，默认小根堆，取出最小的
         *      添加：offer()
         *      移除：poll()
         *      检查：peek()
         * 
         */
        PriorityQueue<Integer> queue1 = new PriorityQueue<>();// 小
        PriorityQueue<Integer> queue2 = new PriorityQueue<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });
        PriorityQueue<Integer> queue3 = new PriorityQueue<>( (a, b) -> b-a );
        queue1.add(2);
        queue1.offer(2);

        // 新数据结构 list<int[]>
        List<int[]> list = new LinkedList<>();
        list.add(new int[]{1, 3});
        System.out.println(list.get(0).length);
    }
    
    @Test
    public void queueTest() {
        /**
         * 初始化 栈，队列
         * 栈的常用方法：
         *      添加：push()
         *      移除：pop()
         *      检查：peek()
         * 队列的常用方法：
         *          返回特殊值 / 抛出异常    在队列满了，或者为空时
         *      添加：offer() / add()
         *      移除：poll()  / remove()
         *      检查：peek()  / element()
         */
        Stack<Integer> stack = new Stack<>();
        Queue<Integer> queue = new LinkedList<>();
        queue.offer(33);
        queue.offer(33);
        System.out.println(queue.size());
        System.out.println(queue.poll());
        System.out.println(queue.poll());
        System.out.println(queue.poll());
        
        Deque<Integer> deque = new LinkedList<>();
        deque.offer(2);
        deque.add(2);
    }

    @Test
    public void testArray() {
        double[] nums = new double[]{23.4543, 87.4523};
        System.out.println(Arrays.toString(nums));
    }
}
